package study.stack;

public class Calculator {
    public static void main(String[] args) {
        //表达式
        String expression = "32+22*6-12";
        //数字桟
        ArrayStack2 numStack = new ArrayStack2(10);
        //符号桟
        ArrayStack2 operStack = new ArrayStack2(10);

        //定义一些相关变量
        int index = 0;
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int result = 0;
        char ch = ' ';

        String keepNum = "";

        //扫描字符串
        while (true){
            ch = expression.substring(index, index + 1).charAt(0);
            //判断扫描的字符是什么
            if (operStack.isOper(ch)){  //如果是符号
                //如果当前符号桟为空，直接入符号栈
                if (operStack.isEmpty()){
                    operStack.push(ch);
                }else { //否则要进行比较优先级

                    int currentOper = ch;   //当前符号
                    int originOper = operStack.peek();  //桟中的栈顶的符号
                    //如果当前的符号的优先级大于符号桟中的操作符，就直接将当前的符号压入符号桟。
                    if (operStack.getPriority(currentOper) > operStack.getPriority(originOper)){
                        operStack.push(currentOper);
                    }else if (operStack.getPriority(currentOper) <= operStack.getPriority(originOper)){
                        // 如果当前的操作符的优先级小于或等于桟中的操作符，
                        // 就从数字桟中pop出两个数字，再从符号桟中pop出一个符号，
                        // 进行运算，将计算的结果push进数字桟，
                        // 然后将刚刚扫描的符号push进符号桟。
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        result = numStack.calculate(num1, num2, oper);
                        numStack.push(result);
                        operStack.push(currentOper);
                    }
                }
            }else { //如果是数字，把扫描的字符入数字桟
                //ch - 48表示ascii码中将字符转换为数字
                //numStack.push(ch - 48);

                //处理多位数
                //处理多位数时，要向expression的表达式的index后再扫一位，如果是数就进行扫描，如果是符号才入栈
                //因此需要一个字符串变量来拼接
                keepNum += ch;

                //如果是表达式的最后，就直接入栈
                if (index == expression.length() - 1){
                    numStack.push(Integer.parseInt(keepNum));
                }else if (operStack.isOper(expression.substring(index+1, index+2).charAt(0))){
                    numStack.push(Integer.parseInt(keepNum));
                    //keepNum要清空，否则下一次扫描时会继续拼接
                    keepNum = "";
                }

            }

            //让index + 1，并判断是否扫描到最后
            index++;
            if (index >= expression.length()){
                break;
            }
        }

        //出栈计算
        while (true){
            if (operStack.isEmpty()){
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            result = numStack.calculate(num1, num2, oper);
            numStack.push(result);
        }

        //最后的桟中只有一个数字，这个数字就是最后的计算结果
        int res = numStack.pop();
        System.out.printf("表达式：%s = %d", expression, res);

    }
}
